#include "DelayDevice.h"
#include <QDebug>
#include <QThread>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QJsonDocument>
#include <QJsonObject>
#include <QEventLoop>
#include <QTimer>
#include <QRegularExpression>
#include <QHostAddress>
#include "DelayCamerDevice_C.h"
//延时设备超时时间（单位：毫秒）
#define DELAY_DEVICE_TIMEOUT 100

//记录所有的DelayDevice对象
 QMap<int,DelayDevice*> DelayDevice::m_sDealyDeviceMap;

/**
 * @brief DelayDevice构造函数，初始化设备连接参数
 * @param deviceIp 设备IP地址
 * @param parent 父对象指针，用于内存管理
 */
DelayDevice::DelayDevice(const QString& deviceIp, QObject *parent)
    : QObject(parent), 
      m_deviceId(0),
      m_deviceIp(deviceIp), 
      m_isConnected(false),
      m_DeviceStatus(false),
      m_CorrectionStatus(false),
      m_FlashStatus(false),
      m_ADIOStatus(false),
      m_IpStatus(false),
      m_CmdSameStatus(false)
{
    m_sDealyDeviceMap[m_deviceId]=this;
    initParameters();
    updateParametersToStruct();
}

/**
 * @brief DelayDevice析构函数，释放资源并关闭连接
 */
DelayDevice::~DelayDevice()
{
    if (m_isConnected)
    {
        close();
    }
}

/**
 * @brief 打开设备连接
 * @return 成功返回true，失败返回false
 */
bool DelayDevice::open()
{
    QMutexLocker locker(&m_mutex);
    
    if (IsOpenTcp())
    {
        if(STS_TCP_CLOSE_SUCCESS!=CloseTcp())
        {
            return false;
        }
        m_isConnected=false;
    }

    if (!ipIsValid(m_deviceIp,&m_ipAddress,&m_port))
    {
        return false;
    }
    
    // 根据IP地址推算子网掩码和网关
    // 这里实现简单的推算逻辑：假设是C类网络，子网掩码为255.255.255.0，网关为网段的第一个IP
    QStringList ipParts = m_ipAddress.split(".");
    if (ipParts.size() == 4)
    {
        // 子网掩码推算：根据IP地址的第一个字节判断网络类型
        int firstOctet = ipParts[0].toInt();
        if (firstOctet >= 1 && firstOctet <= 126)
        {
            // A类网络
            m_subnetMask = "255.0.0.0";
        }
        else if (firstOctet >= 128 && firstOctet <= 191)
        {
            // B类网络
            m_subnetMask = "255.255.0.0";
        }
        else if (firstOctet >= 192 && firstOctet <= 223)
        {
            // C类网络
            m_subnetMask = "255.255.255.0";
        }
        else
        {
            // 其他情况默认使用C类
            m_subnetMask = "255.255.255.0";
        }
        
        // 网关推算：通常为网段的第一个IP（即最后一个字节为1）
        m_gateway = QString("%1.%2.%3.1").arg(ipParts[0]).arg(ipParts[1]).arg(ipParts[2]);
        
    }

    m_IpStatus=false;

    // 设置IP信息到DelayCamerDevice
    SetIpInfo(m_ipAddress.toLatin1().data(),m_subnetMask.toLatin1().data() ,m_gateway.toLatin1().data(),m_port);
    //等待反馈
    QThread::msleep(DELAY_DEVICE_TIMEOUT);

    if(!m_IpStatus)
    {
        return false;
    }

    if(STS_TCP_LINK_SUCCESS != OpenTcp())
    {
        return false;
    }

    //等待连接成功
    QThread::msleep(DELAY_DEVICE_TIMEOUT);

    if(m_isConnected)
    {
        // 使用lambda表达式作为回调函数，并通过super_cast转换为C风格函数指针
        // 这允许我们在C回调中访问对象的成员函数
        SetDevConnCallback(onDeviceConnectStateUpdate);
        SetDevStsCallback(onDeviceStatusUpdate);
        SetCorrStsCallback(onCorrectionStatusUpdate);
        SetFlashStsCallback(onFlashStatusUpdate);
        SetAdIoCallback(onADIOStatusUpdate);
        SetIPStsCallback(onSetIpStatusUpdate);
        SetCmdSameCallback(onCmdSameStatusUpdate);
    }
    // 连接成功
    return m_isConnected;
}

/**
 * @brief 关闭设备连接
 */
void DelayDevice::close()
{
    QMutexLocker locker(&m_mutex);
    
    if (!IsOpenTcp())
    {
        return;
    }
    if(STS_TCP_CLOSE_SUCCESS!=CloseTcp())
    {
        return;
    }
    m_isConnected = false;
}

/**
 * @brief 获取设备参数
 * @param paramName 参数名称
 * @return 参数值，失败返回无效的QVariant
 */
QVariant DelayDevice::getParameter(const QString& paramName) const
{
    QMutexLocker locker(&m_mutex);
    if(!m_ParamsMap.contains(paramName))
    {
        return QVariant();
    }
    return m_ParamsMap.value(paramName);
}

/**
 * @brief 设置参数
 * @param parameters 参数
 */
bool DelayDevice::setParameters(QVariantMap parameters)
{
   return setArgs(parameters)&&setFlashArgs(parameters);
}

/**
 * @brief 获取参数
 * @return 参数
 */
QVariantMap DelayDevice::getParameters()
{
    return m_ParamsMap;
}

/**
 * @brief 设置触发模式
 * @param triggerMode 触发模式（0：外触发模式，1：单次内触发模式，2：聚焦内触发模式，3：停止模式）
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setTriggerMode(int triggerMode)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.mode=(WORKMODE)triggerMode;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[TRIGGER_MODE]=triggerMode;
    }

    return m_DeviceStatus;
}

/**
 * @brief 获取触发模式
 * @return 返回触发模式 （0：外触发模式，1：单次内触发模式，2：聚焦内触发模  式，3：停止模式）
 */
int DelayDevice::getTriggerMode()
{
    return m_ParamsMap[TRIGGER_MODE].toInt();
}

/**
 * @brief 设置精延迟通道使能
 * @param channel 通道号（0：T0 1：T1 2：T2）
 * @param enable true为使能，false为禁用
 */
bool DelayDevice::setPreciseDelayChannelEnable(int channel, bool enable)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.chl_en_x[0][channel]=enable;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[QString(PRECISE_DELAY_ENABLE"_T%1").arg(channel)]=enable;
    }
    return m_DeviceStatus;
}

/**
 * @brief 获取精延迟通道使能状态
 * @param channel 通道号（0：T1 1：T2 3：T3）
 * @return true为使能，false为禁用
 */
bool DelayDevice::getPreciseDelayChannelEnable(int channel)
{
    return m_ParamsMap[QString(PRECISE_DELAY_ENABLE"_T%1").arg(channel)].toBool();
}

/**
 * @brief 设置精FOCUS模式下，精延迟的信号的宽度 
 * @param widthNs_f 脉宽（单位：纳秒）
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setPreciseDelayWidth(quint32 widthNs_f)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.widthNs_f=widthNs_f;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[PRECISE_DELAY_WIDTH_F]=widthNs_f;
    }
    return true;
}

/**
 * @brief 获取精FOCUS模式下，精延迟的信号的宽度
 * @return 脉宽（单位：纳秒）
 */
quint32 DelayDevice::getPreciseDelayWidth()
{
    return m_ParamsMap[PRECISE_DELAY_WIDTH_F].toUInt();
}

/**
 * @brief 设置精FOCUS模式下，精延迟的信号的周期 
 * @param periodNs_f 周期（单位：纳秒）
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setPreciseDelayPeriod(quint32 periodNs_f)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.m_iPeriodNs_f=periodNs_f;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[PRECISE_DELAY_PERIOD_F]=periodNs_f;
    }
    return true;
}

/**
 * @brief 获取FOCUS模式下，精延迟的信号的周期 
 * @return 周期（单位：纳秒）
 */
quint32 DelayDevice::getPreciseDelayPeriod()
{
    return m_ParamsMap[PRECISE_DELAY_PERIOD_F].toUInt();
}

/**
 * @brief 设置精延迟的延时
 * @param channel 通道号（0：T0 1：T1 3：T2）
 * @param delayNs 延时（单位：纳秒）
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setPreciseDelayTime(int channel, double delayNs)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.delayNs_x[m_deviceId][channel]=delayNs/1000;
    m_Args.delayPs_x[m_deviceId][channel]=((quint64)(delayNs*1000))%1000;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[QString(PRECISE_DELAY_ENABLE"_T%1").arg(channel)]=delayNs;
    }
    return true;
}

/**
 * @brief 获取精延迟的延时
 * @param channel 通道号（0：T0 1：T1 3：T2）
 * @return 延时（单位：纳秒）
 */
double DelayDevice::getPreciseDelayTime(int channel)
{
    return m_ParamsMap[QString(PRECISE_DELAY_ENABLE"_T%1").arg(channel)].toDouble();
}

/**
 * @brief 设置精延迟的脉宽
 * @param channel 通道号（0：T0 1：T1 3：T2）
 * @param widthNs 脉宽（单位：纳秒）
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setPreciseDelayWidth(int channel, double widthNs)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.widthNs_x[m_deviceId][channel]=widthNs;
    m_Args.widthNs_x[m_deviceId][channel]=((quint64)(widthNs*1000))%1000;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[QString(PRECISE_DELAY_WIDTH"_T%1").arg(channel)]=widthNs;
    }
    return true;
}

/**
 * @brief 获取精延迟的脉宽
 * @param channel 通道号
 * @return 脉宽（单位：纳秒）
 */
double DelayDevice::getPreciseDelayWidth(int channel)
{
    return m_ParamsMap[QString(PRECISE_DELAY_WIDTH"_T%1").arg(channel)].toDouble();
}

/**
 * @brief 设置IO
 * @param channel 通道号（0：通道1 1：通道2）
 * @param ioValue IO值
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setIO(int channel, quint8 ioValue)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.io_o[m_deviceId][channel]=ioValue;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[QString(IO_VALUE"_%1").arg(channel+1)]=ioValue;
    }
    return true;
}

/**
 * @brief 获取IO
 * @param channel 通道号（0：通道1 1：通道2）
 * @return IO值
 */
quint8 DelayDevice::getIO(int channel)
{
    return m_ParamsMap[QString(IO_VALUE"_%1").arg(channel+1)].toUInt();
}

/**
 * @brief 设置AD
 * @param channel 通道号（0：通道1 1：通道2）
 * @param adValue AD值
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setDA(int channel, double daValue)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_Args.da[m_deviceId][channel]=daValue;
    m_DeviceStatus=false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_DeviceStatus)
    {
        m_ParamsMap[QString(DA_VALUE"_%1").arg(channel+1)]=daValue;
    }
    return true;
}

/**
 * @brief 获取DA
 * @param channel 通道号（0：通道1 1：通道2）
 * @return DA值
 */
double DelayDevice::getDA(int channel)
{
    return m_ParamsMap[QString(DA_VALUE"_%1").arg(channel+1)].toDouble();
}

/**
 * @brief 获取AD
 * @param channel 通道号（0：通道1 1：通道2）
 * @return DA值
 */
double DelayDevice::getAD(int channel)
{
    return m_ParamsMap[QString(AD_VALUE"_%1").arg(channel+1)].toDouble();
}

/**
 * @brief 设置延时到闪存
 * @param channel 通道号（0:T0上升沿 1:T1上升沿 2:T1下降沿 3:T2上升沿 4:T2下降沿）
 * @param delay 延时（单位：纳秒）
 * @param saveToFlash true为保存，false为不保存
 * @return 设置成功返回true，失败返回false  
 */
bool DelayDevice::setDelayToFlash(int channel, double delay, bool saveToFlash)
{
    static QString paramName[]={RISE_EDGE_DELAY_T0,RISE_EDGE_DELAY_T1,FALL_EDGE_DELAY_T1,RISE_EDGE_DELAY_T2,FALL_EDGE_DELAY_T2};
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_FlashArgs.delayNs_x[m_deviceId][channel]=delay;
    m_FlashArgs.delayNs_x[m_deviceId][channel]=((quint64)(delay*1000))%1000;
    m_FlashArgs.isSaveV[m_deviceId]=saveToFlash;
    m_FlashStatus=false;
    SetFlash(&m_FlashArgs);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_FlashStatus)
    {
        m_ParamsMap[paramName[channel]]=delay;
    }
    return true;
}

/**
 * @brief 获取设置到闪存的延时
 * @param channel 通道号（0:T0上升沿 1:T1上升沿 2:T1下降沿 3:T2上升沿 4:T2下降沿）
 * @return 延时（单位：纳秒）
 */
double DelayDevice::getDelayToFlash(int channel)
{
    static QString paramName[]={RISE_EDGE_DELAY_T0,RISE_EDGE_DELAY_T1,FALL_EDGE_DELAY_T1,RISE_EDGE_DELAY_T2,FALL_EDGE_DELAY_T2};
    return m_ParamsMap[paramName[channel]].toDouble();
}

/**
 * @brief 设置宽度到闪存
 * @param channel 通道号（0:T0上升沿 1:T1上升沿 2:T1下降沿 3:T2上升沿 4:T2下降沿）
 * @param width 宽度（单位：纳秒）
 * @param saveToFlash true为保存，false为不保存
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setWidthToFlash(int channel, quint64 width, bool saveToFlash)
{
    static QString paramName[]={RISE_EDGE_WIDTH_T0,RISE_EDGE_WIDTH_T1,FALL_EDGE_WIDTH_T1,RISE_EDGE_WIDTH_T2,FALL_EDGE_WIDTH_T2};
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected)
    {
        return false;
    }
    m_FlashArgs.widthNs_x[m_deviceId][channel]=width;
    m_FlashArgs.isSaveV[m_deviceId]=saveToFlash;
    m_FlashStatus=false;
    SetFlash(&m_FlashArgs);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    if(m_FlashStatus)
    {
        m_ParamsMap[paramName[channel]]=width;
    }
    return true;
}

/**
 * @brief 获取设置到闪存的宽度
 * @param channel 通道号（0:T0上升沿 1:T1上升沿 2:T1下降沿 3:T2上升沿 4:T2下降沿）
 * @return 宽度（单位：纳秒）
 */
quint64 DelayDevice::getWidthToFlash(int channel)
{
    static QString paramName[]={RISE_EDGE_WIDTH_T0,RISE_EDGE_WIDTH_T1,FALL_EDGE_WIDTH_T1,RISE_EDGE_WIDTH_T2,FALL_EDGE_WIDTH_T2};
    return m_ParamsMap[paramName[channel]].toULongLong();
}

/**
 * @brief 初始化设备参数
 */
void DelayDevice::initParameters()
{
    m_ParamsMap[TRIGGER_MODE]=3;
    m_ParamsMap[PRECISE_DELAY_ENABLE_T0]=0;
    m_ParamsMap[PRECISE_DELAY_ENABLE_T1]=0;
    m_ParamsMap[PRECISE_DELAY_ENABLE_T2]=0;
    m_ParamsMap[PRECISE_DELAY_WIDTH_F]=0;
    m_ParamsMap[PRECISE_DELAY_PERIOD_F]=0;
    m_ParamsMap[PRECISE_DELAY_TIME_T0]=0;
    m_ParamsMap[PRECISE_DELAY_TIME_T1]=0;
    m_ParamsMap[PRECISE_DELAY_TIME_T2]=0;
    m_ParamsMap[PRECISE_DELAY_WIDTH_T0]=0;
    m_ParamsMap[PRECISE_DELAY_WIDTH_T1]=0;
    m_ParamsMap[PRECISE_DELAY_WIDTH_T2]=0;
    m_ParamsMap[IO_VALUE_1]=0;
    m_ParamsMap[IO_VALUE_2]=0;
    m_ParamsMap[DA_VALUE_1]=0;
    m_ParamsMap[DA_VALUE_2]=0;
    m_ParamsMap[AD_VALUE_1]=0;
    m_ParamsMap[AD_VALUE_2]=0;
    m_ParamsMap[RISE_EDGE_DELAY_T0]=0;
    m_ParamsMap[RISE_EDGE_DELAY_T1]=0;
    m_ParamsMap[FALL_EDGE_DELAY_T1]=0;
    m_ParamsMap[RISE_EDGE_DELAY_T2]=0;
    m_ParamsMap[FALL_EDGE_DELAY_T2]=0;
    m_ParamsMap[RISE_EDGE_WIDTH_T0]=0;
    m_ParamsMap[RISE_EDGE_WIDTH_T1]=0;
    m_ParamsMap[FALL_EDGE_WIDTH_T1]=0;
    m_ParamsMap[RISE_EDGE_WIDTH_T2]=0;
    m_ParamsMap[FALL_EDGE_WIDTH_T2]=0;
}

/**
 * @brief 更新设备参数到结构体
 */
void DelayDevice::updateParametersToStruct()
{
    m_Args.mode=(WORKMODE)m_ParamsMap[TRIGGER_MODE].toInt();
    m_Args.chl_en_x[m_deviceId][0]=m_ParamsMap[PRECISE_DELAY_ENABLE_T0].toBool();
    m_Args.chl_en_x[m_deviceId][1]=m_ParamsMap[PRECISE_DELAY_ENABLE_T1].toBool();
    m_Args.chl_en_x[m_deviceId][2]=m_ParamsMap[PRECISE_DELAY_ENABLE_T2].toBool();
    m_Args.widthNs_f=m_ParamsMap[PRECISE_DELAY_WIDTH_F].toUInt();
    m_Args.m_iPeriodNs_f=m_ParamsMap[PRECISE_DELAY_PERIOD_F].toUInt();
    m_Args.delayNs_x[m_deviceId][0]=m_ParamsMap[PRECISE_DELAY_TIME_T0].toDouble();
    m_Args.delayNs_x[m_deviceId][1]=m_ParamsMap[PRECISE_DELAY_TIME_T1].toDouble();
    m_Args.delayNs_x[m_deviceId][2]=m_ParamsMap[PRECISE_DELAY_TIME_T2].toDouble();
    m_Args.delayNs_x[m_deviceId][0]=((quint64)(m_ParamsMap[PRECISE_DELAY_TIME_T0].toDouble()*1000))%1000;
    m_Args.delayNs_x[m_deviceId][1]=((quint64)(m_ParamsMap[PRECISE_DELAY_TIME_T1].toDouble()*1000))%1000;
    m_Args.delayNs_x[m_deviceId][2]=((quint64)(m_ParamsMap[PRECISE_DELAY_TIME_T2].toDouble()*1000))%1000;
    m_Args.widthNs_x[m_deviceId][0]=m_ParamsMap[PRECISE_DELAY_WIDTH_T0].toDouble();
    m_Args.widthNs_x[m_deviceId][1]=m_ParamsMap[PRECISE_DELAY_WIDTH_T1].toDouble();
    m_Args.widthNs_x[m_deviceId][2]=m_ParamsMap[PRECISE_DELAY_WIDTH_T2].toDouble();
    m_Args.widthNs_x[m_deviceId][0]=((quint64)(m_ParamsMap[PRECISE_DELAY_WIDTH_T0].toDouble()*1000))%1000;
    m_Args.widthNs_x[m_deviceId][1]=((quint64)(m_ParamsMap[PRECISE_DELAY_WIDTH_T1].toDouble()*1000))%1000;
    m_Args.widthNs_x[m_deviceId][2]=((quint64)(m_ParamsMap[PRECISE_DELAY_WIDTH_T2].toDouble()*1000))%1000;
    m_Args.io_o[m_deviceId][0]=m_ParamsMap[IO_VALUE_1].toUInt();
    m_Args.io_o[m_deviceId][1]=m_ParamsMap[IO_VALUE_2].toUInt();
    m_Args.da[m_deviceId][0]=m_ParamsMap[DA_VALUE_1].toDouble();
    m_Args.da[m_deviceId][1]=m_ParamsMap[DA_VALUE_2].toDouble();
    m_Args.isSetMode[0] = true;
    m_Args.isSetX[0] = true;
    m_Args.isSetIO[0] = true;
    m_Args.isSetDA[0] = true;

    m_FlashArgs.delayNs_x[m_deviceId][0]=m_ParamsMap[RISE_EDGE_DELAY_T0].toDouble();
    m_FlashArgs.delayNs_x[m_deviceId][1]=m_ParamsMap[RISE_EDGE_DELAY_T1].toDouble();
    m_FlashArgs.delayNs_x[m_deviceId][2]=m_ParamsMap[FALL_EDGE_DELAY_T1].toDouble();
    m_FlashArgs.delayNs_x[m_deviceId][3]=m_ParamsMap[RISE_EDGE_DELAY_T2].toDouble();
    m_FlashArgs.delayNs_x[m_deviceId][4]=m_ParamsMap[FALL_EDGE_DELAY_T2].toDouble();
    m_FlashArgs.delayNs_x[m_deviceId][0]=((quint64)(m_ParamsMap[RISE_EDGE_DELAY_T0].toDouble()*1000))%1000;
    m_FlashArgs.delayNs_x[m_deviceId][1]=((quint64)(m_ParamsMap[RISE_EDGE_DELAY_T1].toDouble()*1000))%1000;
    m_FlashArgs.delayNs_x[m_deviceId][2]=((quint64)(m_ParamsMap[FALL_EDGE_DELAY_T1].toDouble()*1000))%1000;
    m_FlashArgs.delayNs_x[m_deviceId][3]=((quint64)(m_ParamsMap[RISE_EDGE_DELAY_T2].toDouble()*1000))%1000;
    m_FlashArgs.delayNs_x[m_deviceId][4]=((quint64)(m_ParamsMap[FALL_EDGE_DELAY_T2].toDouble()*1000))%1000;

    m_FlashArgs.widthNs_x[m_deviceId][0]=m_ParamsMap[RISE_EDGE_WIDTH_T0].toULongLong();
    m_FlashArgs.widthNs_x[m_deviceId][1]=m_ParamsMap[RISE_EDGE_WIDTH_T1].toULongLong();
    m_FlashArgs.widthNs_x[m_deviceId][2]=m_ParamsMap[FALL_EDGE_WIDTH_T1].toULongLong();
    m_FlashArgs.widthNs_x[m_deviceId][3]=m_ParamsMap[RISE_EDGE_WIDTH_T2].toULongLong();
    m_FlashArgs.widthNs_x[m_deviceId][4]=m_ParamsMap[FALL_EDGE_WIDTH_T2].toULongLong();

    m_FlashArgs.isSaveV[m_deviceId]=m_ParamsMap[IS_WRITE_FLASHE].toBool();
}

/**
 * @brief 处理设备连接状态更新
 */
void DelayDevice::onDeviceConnectStateUpdate(void)
{
    m_sDealyDeviceMap.value(0)->m_isConnected=true;
}

/**
 * @brief 处理设备状态更新
 * @param inst 设备状态更新结构体指针
 */
void DelayDevice::onDeviceStatusUpdate(str_UpInfo_DevSts* inst)
{
    DelayDevice *pDelayDevice=m_sDealyDeviceMap.value(0);
    pDelayDevice->m_DeviceStatus= inst->sts[pDelayDevice->m_deviceId];
}

/**
 * @brief 处理校正状态更新
 * @param inst 校正状态更新结构体指针
 */
void DelayDevice::onCorrectionStatusUpdate(str_UpInfo_CorrSts* inst)
{
    DelayDevice *pDelayDevice=m_sDealyDeviceMap.value(0);
    pDelayDevice->m_CorrectionStatus= inst->sts[pDelayDevice->m_deviceId];
}

/**
 * @brief 处理闪存状态更新
 * @param inst 闪存状态更新结构体指针
 */
void DelayDevice::onFlashStatusUpdate(str_UpInfo_FlashSts* inst)
{
    DelayDevice *pDelayDevice=m_sDealyDeviceMap.value(0);
    pDelayDevice->m_FlashStatus= inst->sts[pDelayDevice->m_deviceId];
}

/**
 * @brief 处理AD/IO状态更新
 * @param inst AD/IO状态更新结构体指针
 */
void DelayDevice::onADIOStatusUpdate(str_UpInfo_AD_IO* inst)
{
    DelayDevice *pDelayDevice=m_sDealyDeviceMap.value(0);
    pDelayDevice->m_ParamsMap[AD_VALUE_1]= inst->ad[pDelayDevice->m_deviceId*ONE_DEVICE_AD];
    pDelayDevice->m_ParamsMap[AD_VALUE_2]= inst->ad[pDelayDevice->m_deviceId*ONE_DEVICE_AD+1];
}

/**
 * @brief 处理设置IP状态更新
 * @param inst 设置IP状态更新结构体指针
 */
void DelayDevice::onSetIpStatusUpdate(unsigned char setIpSts)
{
    DelayDevice *pDelayDevice=m_sDealyDeviceMap.value(0);
    pDelayDevice->m_IpStatus=setIpSts;
}

/**
 * @brief 处理命令相同状态更新
 * @param inst 命令相同状态更新结构体指针
 */
void DelayDevice::onCmdSameStatusUpdate(void)
{
    DelayDevice *pDelayDevice=m_sDealyDeviceMap.value(0);
    pDelayDevice->m_CmdSameStatus=true;
}

/**
 * @brief 设置设备普通参数
 * @param paramsMap 参数映射表
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setArgs(const QVariantMap& paramsMap)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected) {
        return false;
    }
    
    // 临时保存当前参数映射表，用于回滚
    QVariantMap tempParamsMap = this->m_ParamsMap;
    
    // 临时更新内部参数映射表，用于生成结构体
    for (auto it = paramsMap.constBegin(); it != paramsMap.constEnd(); ++it) {
        this->m_ParamsMap[it.key()] = it.value();
    }
    
    // 将参数从映射表更新到结构体
    updateParametersToStruct();
    
    // 调用底层函数设置参数
    m_DeviceStatus = false;
    SetArgs(&m_Args);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    // 检查设置结果
    if (m_DeviceStatus)
    {
        // 设置成功，保持更新后的参数映射表
        return true;
    }

    // 设置失败，回滚参数映射表
    this->m_ParamsMap = tempParamsMap;
    return false;
}

/**
 * @brief 设置设备闪存参数
 * @param paramsMap 参数映射表
 * @return 设置成功返回true，失败返回false
 */
bool DelayDevice::setFlashArgs(const QVariantMap& paramsMap)
{
    QMutexLocker locker(&m_mutex);
    if (!m_isConnected) {
        return false;
    }
    
    // 临时保存当前参数映射表，用于回滚
    QVariantMap tempParamsMap = this->m_ParamsMap;
    
    // 临时更新内部参数映射表，用于生成结构体
    for (auto it = paramsMap.constBegin(); it != paramsMap.constEnd(); ++it) {
        this->m_ParamsMap[it.key()] = it.value();
    }
    
    // 将参数从映射表更新到结构体
    updateParametersToStruct();
    
    // 调用底层函数设置闪存参数
    m_FlashStatus = false;
    SetFlash(&m_FlashArgs);
    QThread::msleep(DELAY_DEVICE_TIMEOUT);
    // 检查设置结果
    if (m_FlashStatus)
    {
        // 设置成功，保持更新后的参数映射表
        return true;
    }
    // 设置失败，回滚参数映射表
    this->m_ParamsMap = tempParamsMap;
    return false;
}

/**
 * @brief ip是否有效
 * @param ipInfo  ip信息字符串
 * @param ip 返回从信息中获取的设备ip
 * @param port 返回从信息中获取的设备端口
 * @return 是否有效
 */
bool DelayDevice::ipIsValid(const QString &ipInfo, QString *pINstring, quint16 *pPort)
{
    // 检查ipInfo是否为空
    if (ipInfo.isEmpty()) {
        return false;
    }
    
    // 检查ipInfo是否包含":"
    if (!ipInfo.contains(":")) {
        return false;
    }
    
    // 从ipInfo中提取ip和端口
    QStringList parts = ipInfo.split(":");
    if (parts.size() != 2) {
        return false;
    }
    
    // 检查ip是否有效
    QString ip=parts[0];
    if (QHostAddress(ip).isNull()) {
        return false;
    }
    
    // 检查端口是否有效
    bool ok;
    quint16 port=parts[1].toUShort(&ok);
    if (!ok || port < 1) {
        return false;
    }
    if(pINstring)*pINstring = ip;
    if(pPort)*pPort = port;
    return true;
}
